package com.googlecode.lemyriapode.type;

import java.util.Arrays;
import static com.googlecode.lemyriapode.type.Echiquier.Direction.*;
import java.util.List;

public class Echiquier {

    /**
     * colonne i  EST (a->b ...)
     * rang j     NORD (1->2...)
     *
     */
    public enum Case {

        a1, b1, c1, d1, e1, f1, g1, h1,
        a2, b2, c2, d2, e2, f2, g2, h2,
        a3, b3, c3, d3, e3, f3, g3, h3,
        a4, b4, c4, d4, e4, f4, g4, h4,
        a5, b5, c5, d5, e5, f5, g5, h5,
        a6, b6, c6, d6, e6, f6, g6, h6,
        a7, b7, c7, d7, e7, f7, g7, h7,
        a8, b8, c8, d8, e8, f8, g8, h8, out;

        public final int Ci() {
            return ordinal() % 8;
        }

        public final int Rj() {
            return ordinal() / 8;
        }

        public final static Case getCase(int i, int j) {
            return values()[i + 8 * j];
        }

        public final Case next() {
            return values()[ordinal() + 1];
        }
    }
    /**
     * Lignes essentielles de l'échiquier
     */
    public static Direction[] HV = {nord, est, sud, ouest};
    public static Direction[] D = {nord_est, sud_est, sud_ouest, nord_ouest};
    public static Direction[] HVD = {nord, est, sud, ouest, nord_est, sud_est, sud_ouest, nord_ouest};
    public static Direction[] Cavalier = null;
    public static Direction[] Pion = null;

    public enum Direction {

        nord(0, 1),
        nord_est(1, 1),
        est(1, 0),
        sud_est(1, -1),
        sud(0, -1),
        sud_ouest(-1, -1),
        ouest(-1, 0),
        nord_ouest(-1, 1),
        cav1, cav2, cav3, cav4, cav5, cav6, cav7, cav8;
        public int u,  v;

        private Direction() {
        }

        private Direction(int u, int v) {
            this.u = u;
            this.v = v;
        }

        /**
         *
         * @param Regle_Mouvt
         * @return vrai si la dir étudiée fait partie
         *                  des règles de la pièce en cours
         */
        public final boolean estInclus(Direction[] Regle_Mouvt) {
            List<Direction> L = Arrays.asList(Regle_Mouvt);
            return L.contains(this);
        }

        public final Direction next() {
            return values()[ordinal() + 1];
        }
    }
    public Case _c;
    public Direction dir;

    public Echiquier() {
        _c = Case.a1;
        dir = Direction.nord;
    }

    public Echiquier(Case c, Direction dir) {
        _c = c;
        this.dir = dir;
    }

    /**
     *
     * @param I
     * @param J
     * @return vrai si la case en paramètre n'existe pas (sortie de l'échiquier)
     */
    public static boolean isOut(int I, int J) {
        return (I < 0) || (I > 7) || (J < 0) || (J > 7);
    }
}


